

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>Fortran Table for dynamically extendable arrays &mdash; quippy 7ea04c5+ documentation</title>
  

  
  
    <link rel="shortcut icon" href="_static/favicon.ico"/>
  
  
  

  
  <script type="text/javascript" src="_static/js/modernizr.min.js"></script>
  
    
      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
        <script type="text/javascript" src="_static/jquery.js"></script>
        <script type="text/javascript" src="_static/underscore.js"></script>
        <script type="text/javascript" src="_static/doctools.js"></script>
        <script type="text/javascript" src="_static/language_data.js"></script>
        <script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"processClass": "math|output_area", "processEscapes": true, "ignoreClass": "document", "inlineMath": [["$", "$"], ["\\(", "\\)"]]}})</script>
    
    <script type="text/javascript" src="_static/js/theme.js"></script>

    

  
  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
  <link rel="stylesheet" href="_static/theme_overrides.css" type="text/css" />
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" /> 
</head>

<body class="wy-body-for-nav">

   
  <div class="wy-grid-for-nav">
    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search" >
          

          
            <a href="index.html" class="icon icon-home"> quippy
          

          
            
            <img src="_static/hybrid.png" class="logo" alt="Logo"/>
          
          </a>

          
            
            
              <div class="version">
                7ea04c5+
              </div>
            
          

          
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          
        </div>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
    
            
            
              
            
            
              <ul class="current">
<li class="toctree-l1"><a class="reference internal" href="intro.html">Introduction to <code class="docutils literal notranslate"><span class="pre">quippy</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="install.html">Installation of QUIP and quippy</a></li>
<li class="toctree-l1"><a class="reference internal" href="Tutorials/index.html">Tutorials</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="quippy.html">Quippy library reference</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="quippy.html#core-functionality">Core functionality</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#structure-generation-manipulation-and-analysis">Structure generation, manipulation and analysis</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#molecular-dynamics">Molecular Dynamics</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#additional-tools-for-potentials">Additional tools for Potentials</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#mathematical-and-optimisation-tools">Mathematical and optimisation tools</a></li>
<li class="toctree-l2"><a class="reference internal" href="quippy.html#units-data-and-constants">Units, Data and Constants</a></li>
<li class="toctree-l2 current"><a class="reference internal" href="quippy.html#low-level-routines-and-datatypes">Low level routines and datatypes</a><ul class="current">
<li class="toctree-l3"><a class="reference internal" href="system.html">Low-level system routines</a></li>
<li class="toctree-l3"><a class="reference internal" href="connection.html">Connection objects</a></li>
<li class="toctree-l3"><a class="reference internal" href="dictionary.html">Fortran Dictionary objects for storing key/value pairs</a></li>
<li class="toctree-l3"><a class="reference internal" href="domaindecomposition.html">DomainDecomposition objects</a></li>
<li class="toctree-l3 current"><a class="current reference internal" href="#">Fortran <code class="docutils literal notranslate"><span class="pre">Table</span></code> for dynamically extendable arrays</a><ul class="simple">
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="mpi_context.html">MPI parallel interface</a></li>
<li class="toctree-l3"><a class="reference internal" href="paramreader.html">Command line argument parser</a></li>
<li class="toctree-l3"><a class="reference internal" href="fortranio.html">Fortran input/output</a></li>
<li class="toctree-l3"><a class="reference internal" href="farray.html">FortranArray objects for one-based array indexing</a></li>
<li class="toctree-l3"><a class="reference internal" href="util.html">Utility functions</a></li>
<li class="toctree-l3"><a class="reference internal" href="qpxml.html">GAP XML functions</a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="visualisation.html">Visualisation Tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="fortran_wrapper.html">Appendix: wrapping Fortran 90 Code</a></li>
<li class="toctree-l1"><a class="reference internal" href="teach_sparse.html">Command line options of the teach_sparse main program</a></li>
</ul>

            
          
    <p></p>
    <ul>
        <li><a href="genindex.html">Index</a></li>
        <li><a href="py-modindex.html">Module Index</a></li>
        <li><a href="search.html">Search Page</a></li>
        <li><a href="_modules/index.html">Module Source Code</a></li>
    </ul>
  
        </div>
      </div>
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="index.html">quippy</a>
        
      </nav>


      <div class="wy-nav-content">
        
        <div class="rst-content">
        
          















<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="index.html">Docs</a> &raquo;</li>
        
          <li><a href="quippy.html">Quippy library reference</a> &raquo;</li>
        
      <li>Fortran <code class="docutils literal notranslate"><span class="pre">Table</span></code> for dynamically extendable arrays</li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/table.rst.txt" rel="nofollow"> View page source</a>
          
        
      </li>
    
  </ul>

  
  <hr/>
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
  
<style>
/* CSS overrides for sphinx_rtd_theme */

/* 24px margin */
.nbinput.nblast,
.nboutput.nblast {
    margin-bottom: 19px;  /* padding has already 5px */
}

/* ... except between code cells! */
.nblast + .nbinput {
    margin-top: -19px;
}

.admonition > p:before {
    margin-right: 4px;  /* make room for the exclamation icon */
}

/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
.math {
    text-align: unset;
}
</style>
<div class="section" id="module-quippy.table">
<span id="fortran-table-for-dynamically-extendable-arrays"></span><h1>Fortran <code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code> for dynamically extendable arrays<a class="headerlink" href="#module-quippy.table" title="Permalink to this headline">¶</a></h1>
<p>A <code class="docutils literal notranslate"><span class="pre">Table</span></code> is an extensible 2D array of integers, reals, strings and logicals.
The lengths of all rows are the same and the number of rows will grow and shrink
as datais appended or deleted. Extra columns can also be appended, although this
is envisaged to be required less often. Any of the number of integers,
number of reals, number of strings and number of logicals can be zero</p>
<p>Integers are referenced by    <code class="docutils literal notranslate"><span class="pre">table.int</span></code></p>
<p>Reals are referenced by       <code class="docutils literal notranslate"><span class="pre">table.real</span></code></p>
<p>Strings are referenced by     <code class="docutils literal notranslate"><span class="pre">table.str</span></code></p>
<p>Logicals are referenced by    <code class="docutils literal notranslate"><span class="pre">table.logical</span></code></p>
<p>Appending to the table is through the <code class="docutils literal notranslate"><span class="pre">append</span></code> interface.</p>
<p>Module contents for <a class="reference internal" href="#module-quippy.table" title="quippy.table: Fortran type for dynamically extendable arrays"><code class="xref py py-mod docutils literal notranslate"><span class="pre">quippy.table</span></code></a>:</p>
<p class="rubric">Classes</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-obj docutils literal notranslate"><span class="pre">Table</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
</tbody>
</table>
<p class="rubric">Attributes</p>
<table border="1" class="docutils">
<colgroup>
<col width="84%" />
<col width="16%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Name</th>
<th class="head">Value</th>
</tr>
</thead>
<tbody valign="top">
<tr class="row-even"><td><code class="xref py py-attr docutils literal notranslate"><span class="pre">TABLE_STRING_LENGTH</span></code></td>
<td>10</td>
</tr>
</tbody>
</table>
<dl class="class">
<dt id="quippy.table.Table">
<em class="property">class </em><code class="descclassname">quippy.table.</code><code class="descname">Table</code><span class="sig-paren">(</span><span class="optional">[</span><em>nint</em>, <em>nreal</em>, <em>nstr</em>, <em>nlogical</em>, <em>max_length</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/table.html#Table"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.table.Table" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">quippy._table.Table</span></code></p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>nint</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of integer columns</p>
</dd>
<dt><strong>nreal</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of real columns</p>
</dd>
<dt><strong>nstr</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of string columns</p>
</dd>
<dt><strong>nlogical</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of logical columns</p>
</dd>
<dt><strong>max_length</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of rows to initially allocate</p>
</dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_allocate</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.
Class is wrapper around Fortran type <code class="docutils literal notranslate"><span class="pre">Table</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Attributes:</th><td class="field-body"><dl class="first last docutils">
<dt><a class="reference internal" href="#quippy.table.Table.increment" title="quippy.table.Table.increment"><code class="xref py py-obj docutils literal notranslate"><span class="pre">increment</span></code></a></dt>
<dd><p class="first last">How many rows to grow the table by on reallocation (default 1000)</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.int" title="quippy.table.Table.int"><code class="xref py py-obj docutils literal notranslate"><span class="pre">int</span></code></a></dt>
<dd><p class="first last">(intsize,N) array of integer data</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.intsize" title="quippy.table.Table.intsize"><code class="xref py py-obj docutils literal notranslate"><span class="pre">intsize</span></code></a></dt>
<dd><p class="first last">Number of integer columns</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.logical" title="quippy.table.Table.logical"><code class="xref py py-obj docutils literal notranslate"><span class="pre">logical</span></code></a></dt>
<dd><p class="first last">(logicalsize,N) array of logical data</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.logicalsize" title="quippy.table.Table.logicalsize"><code class="xref py py-obj docutils literal notranslate"><span class="pre">logicalsize</span></code></a></dt>
<dd><p class="first last">Number of logical columns</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.max_length" title="quippy.table.Table.max_length"><code class="xref py py-obj docutils literal notranslate"><span class="pre">max_length</span></code></a></dt>
<dd><p class="first last">Initial maximum length of the table before the first reallocation (default 100)</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.n" title="quippy.table.Table.n"><code class="xref py py-obj docutils literal notranslate"><span class="pre">n</span></code></a></dt>
<dd><p class="first last">Number of rows</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.real" title="quippy.table.Table.real"><code class="xref py py-obj docutils literal notranslate"><span class="pre">real</span></code></a></dt>
<dd><p class="first last">(realsize,N) array of real data</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.realsize" title="quippy.table.Table.realsize"><code class="xref py py-obj docutils literal notranslate"><span class="pre">realsize</span></code></a></dt>
<dd><p class="first last">Number of real columns</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.str" title="quippy.table.Table.str"><code class="xref py py-obj docutils literal notranslate"><span class="pre">str</span></code></a></dt>
<dd><p class="first last">(strsize,N) array of string data</p>
</dd>
<dt><a class="reference internal" href="#quippy.table.Table.strsize" title="quippy.table.Table.strsize"><code class="xref py py-obj docutils literal notranslate"><span class="pre">strsize</span></code></a></dt>
<dd><p class="first last">Number of string columns</p>
</dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">Methods</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.allocate" title="quippy.table.Table.allocate"><code class="xref py py-obj docutils literal notranslate"><span class="pre">allocate</span></code></a>(…)</td>
<td>Allocate a <code class="docutils literal notranslate"><span class="pre">Table</span></code>.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.append" title="quippy.table.Table.append"><code class="xref py py-obj docutils literal notranslate"><span class="pre">append</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Append rows to a table.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.append_column" title="quippy.table.Table.append_column"><code class="xref py py-obj docutils literal notranslate"><span class="pre">append_column</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Append 1 or more columns to a table.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.delete" title="quippy.table.Table.delete"><code class="xref py py-obj docutils literal notranslate"><span class="pre">delete</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Delete a row by index or by value.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.delete_multiple" title="quippy.table.Table.delete_multiple"><code class="xref py py-obj docutils literal notranslate"><span class="pre">delete_multiple</span></code></a>(indices)</td>
<td>Delete multiple rows from a Table.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.find" title="quippy.table.Table.find"><code class="xref py py-obj docutils literal notranslate"><span class="pre">find</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Search the integer part of a table for a given element or array.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.from_atom_indices" title="quippy.table.Table.from_atom_indices"><code class="xref py py-obj docutils literal notranslate"><span class="pre">from_atom_indices</span></code></a>(atoms[,&nbsp;mask,&nbsp;list,&nbsp;…])</td>
<td>Construct a new Table containing atomic indices from a list or mask</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.from_atom_list" title="quippy.table.Table.from_atom_list"><code class="xref py py-obj docutils literal notranslate"><span class="pre">from_atom_list</span></code></a>(atoms,&nbsp;list[,&nbsp;…])</td>
<td>Construct a new Table from a list of atom indices</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.from_atom_mask" title="quippy.table.Table.from_atom_mask"><code class="xref py py-obj docutils literal notranslate"><span class="pre">from_atom_mask</span></code></a>(atoms,&nbsp;mask[,&nbsp;…])</td>
<td>Construct a new Table from an atom mask</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.insert" title="quippy.table.Table.insert"><code class="xref py py-obj docutils literal notranslate"><span class="pre">insert</span></code></a>(…)</td>
<td>insert a row at a given position</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.int_part" title="quippy.table.Table.int_part"><code class="xref py py-obj docutils literal notranslate"><span class="pre">int_part</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Utility function to return one or more columns from the integer part of a table.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.int_subtable" title="quippy.table.Table.int_subtable"><code class="xref py py-obj docutils literal notranslate"><span class="pre">int_subtable</span></code></a>(rows,cols)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-obj docutils literal notranslate"><span class="pre">is_same_fortran_object</span></code>(other)</td>
<td>Test if <cite>self</cite> and <cite>other</cite> point to the same Fortan object.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.logical_part" title="quippy.table.Table.logical_part"><code class="xref py py-obj docutils literal notranslate"><span class="pre">logical_part</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">logical_part</span></code> containing multiple routines:</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.print_" title="quippy.table.Table.print_"><code class="xref py py-obj docutils literal notranslate"><span class="pre">print_</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Print this table to the mainlog or to an inoutput object.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.real_part" title="quippy.table.Table.real_part"><code class="xref py py-obj docutils literal notranslate"><span class="pre">real_part</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Utility function to return one or more columns from the real part of a table.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.record_delete_multiple" title="quippy.table.Table.record_delete_multiple"><code class="xref py py-obj docutils literal notranslate"><span class="pre">record_delete_multiple</span></code></a>(indices)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.remove_columns" title="quippy.table.Table.remove_columns"><code class="xref py py-obj docutils literal notranslate"><span class="pre">remove_columns</span></code></a>(…)</td>
<td>remove a range of columns from a table’s int or real parts</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.search" title="quippy.table.Table.search"><code class="xref py py-obj docutils literal notranslate"><span class="pre">search</span></code></a>(intpart)</td>
<td>Do a binary search (faster than find) on a pre-sorted table</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.select" title="quippy.table.Table.select"><code class="xref py py-obj docutils literal notranslate"><span class="pre">select</span></code></a>(to,from,[row_mask,row_list])</td>
<td>Select certains rows from a table based on a mask</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.set_increment" title="quippy.table.Table.set_increment"><code class="xref py py-obj docutils literal notranslate"><span class="pre">set_increment</span></code></a>(increment)</td>
<td>Change the increment for this table.</td>
</tr>
<tr class="row-even"><td><code class="xref py py-obj docutils literal notranslate"><span class="pre">shallow_copy</span></code>()</td>
<td>Return a shallow copy of <cite>self</cite>.</td>
</tr>
<tr class="row-odd"><td><code class="xref py py-obj docutils literal notranslate"><span class="pre">shallow_copy_from</span></code>(other)</td>
<td>Transform <cite>self</cite> into a shallow copy of <cite>other</cite>.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.sort" title="quippy.table.Table.sort"><code class="xref py py-obj docutils literal notranslate"><span class="pre">sort</span></code></a>([idx,int_cols])</td>
<td>Sort a table according to its int part</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.str_part" title="quippy.table.Table.str_part"><code class="xref py py-obj docutils literal notranslate"><span class="pre">str_part</span></code></a>(*args,&nbsp;**kwargs)</td>
<td>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">str_part</span></code> containing multiple routines:</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.subtable" title="quippy.table.Table.subtable"><code class="xref py py-obj docutils literal notranslate"><span class="pre">subtable</span></code></a>(…)</td>
<td><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"></td>
</tr>
</tbody>
</table>
</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.to_atom_list" title="quippy.table.Table.to_atom_list"><code class="xref py py-obj docutils literal notranslate"><span class="pre">to_atom_list</span></code></a>([atoms])</td>
<td>Return list of atom indices that this Table represents.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#quippy.table.Table.to_atom_mask" title="quippy.table.Table.to_atom_mask"><code class="xref py py-obj docutils literal notranslate"><span class="pre">to_atom_mask</span></code></a>([atoms])</td>
<td>Return mask for atom indices that this Table represents</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#quippy.table.Table.wipe" title="quippy.table.Table.wipe"><code class="xref py py-obj docutils literal notranslate"><span class="pre">wipe</span></code></a>([zero])</td>
<td>Clear this table, but keep the allocation.</td>
</tr>
</tbody>
</table>
<dl class="method">
<dt id="quippy.table.Table.allocate">
<code class="descname">allocate</code><span class="sig-paren">(</span><span class="optional">[</span><em>nint</em>, <em>nreal</em>, <em>nstr</em>, <em>nlogical</em>, <em>max_length</em>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.allocate" title="Permalink to this definition">¶</a></dt>
<dd><p>Allocate a <code class="docutils literal notranslate"><span class="pre">Table</span></code>. When allocating a table, you can
optionally specify the number of integer and real columns and the
initial amount of space to allocate (<code class="docutils literal notranslate"><span class="pre">max_length</span></code>). If a table is
unallocated when append is called for the first time it will be
allocated accordingly.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>nint</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of integer columns</p>
</dd>
<dt><strong>nreal</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of real columns</p>
</dd>
<dt><strong>nstr</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of string columns</p>
</dd>
<dt><strong>nlogical</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of logical columns</p>
</dd>
<dt><strong>max_length</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd><p class="first last">Number of rows to initially allocate</p>
</dd>
<dt><strong>error</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-0 array(int,’i’), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">__init__allocate</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.append">
<code class="descname">append</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.append" title="Permalink to this definition">¶</a></dt>
<dd><p>Append rows to a table. Overloaded to be able to append single elements,
arrays or other tables.</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">append</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>intpart</em>, <em>realpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>intpart</strong> (<em>input int</em>) – </li>
<li><strong>realpart</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_int_element_real_row</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>intpart</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>intpart</strong> (<em>input int</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_int_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>intpart</em>, <em>realpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>intpart</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>realpart</strong> (<em>input float</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_int_row_real_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>intpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>intpart</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_int_array</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>realpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>realpart</strong> (<em>input float</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_real_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>other</strong> (<code class="xref py py-class docutils literal notranslate"><span class="pre">table</span></code> object) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_table</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>strpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>strpart</strong> (<em>input rank-3 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>,</em><em>(</em><em>10</em><em>)</em><em>)</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_str_array</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>logicalpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>logicalpart</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_logical_array</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>strpart</em><span class="optional">[</span>, <em>error</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>strpart</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em>) – </li>
<li><strong>error</strong> (<em>in/output rank-0 array</em><em>(</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><em>int</em></a><em>,</em><em>'i'</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_str_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>logicalpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>logicalpart</strong> (<em>input int</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_logical_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>realpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>realpart</strong> (<em>input rank-2 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>qp_n1</em><em>)</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_real_array</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><span class="optional">[</span><em>intpart</em>, <em>realpart</em>, <em>strpart</em>, <em>logicalpart</em>, <em>intpart_2d</em>, <em>realpart_2d</em>, <em>strpart_2d</em>, <em>logicalpart_2d</em>, <em>blank_rows</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>intpart</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>realpart</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n1</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>strpart</strong> (<em>input rank-2 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n2</em><em>,</em><em>(</em><em>10</em><em>)</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>logicalpart</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n3</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>intpart_2d</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n4</em><em>,</em><em>qp_n5</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>realpart_2d</strong> (<em>input rank-2 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n6</em><em>,</em><em>qp_n7</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>strpart_2d</strong> (<em>input rank-3 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n8</em><em>,</em><em>qp_n9</em><em>,</em><em>(</em><em>10</em><em>)</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>logicalpart_2d</strong> (<em>input rank-2 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n10</em><em>,</em><em>qp_n11</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>blank_rows</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_row_or_arrays</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append</code><span class="sig-paren">(</span><em>intpart</em>, <em>realpart</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>intpart</strong> (<em>input int</em>) – </li>
<li><strong>realpart</strong> (<em>input float</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_int_element_and_real_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.append_column">
<code class="descname">append_column</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.append_column" title="Permalink to this definition">¶</a></dt>
<dd><p>Append 1 or more columns to a table.  Overloaded to be able to append
a scalar, 1-D array (must match N rows), or other tables (must match N rows)</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">append_column</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val</strong> (<em>input int</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_i</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val</strong> (<em>input int</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_l</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val</strong> (<em>input string</em><em>(</em><em>len=10</em><em>)</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_s</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val</strong> (<em>input float</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_r</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val_a</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val_a</strong> (<em>input rank-2 array</em><em>(</em><em>'S'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>,</em><em>(</em><em>10</em><em>)</em><em>)</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_s_a</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val_a</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val_a</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_i_a</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>other</strong> (<a class="reference internal" href="#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_table</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val_a</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val_a</strong> (<em>input rank-1 array</em><em>(</em><em>'d'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_r_a</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">append_column</code><span class="sig-paren">(</span><em>val_a</em><span class="optional">[</span>, <em>n_cols</em>, <em>cols</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>val_a</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n_cols</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>cols</strong> (<em>in/output rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>2</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_append_col_l_a</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.delete">
<code class="descname">delete</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.delete" title="Permalink to this definition">¶</a></dt>
<dd><p>Delete a row by index or by value. If by value then the match
is made by the integer part of the table. The last row is copied
over the row to be deleted, so the order of rows is not maintained.</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">delete</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">delete</code><span class="sig-paren">(</span><em>n</em><span class="optional">[</span>, <em>keep_order</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>n</strong> (<em>input int</em>) – </li>
<li><strong>keep_order</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_record_delete_by_index</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">delete</code><span class="sig-paren">(</span><em>n</em><span class="optional">[</span>, <em>keep_order</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>n</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>n0</em><em>)</em>) – </li>
<li><strong>keep_order</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_record_delete_by_value</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.delete_multiple">
<code class="descname">delete_multiple</code><span class="sig-paren">(</span><em>indices</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.delete_multiple" title="Permalink to this definition">¶</a></dt>
<dd><p>Delete multiple rows from a Table. Beware, the order of rows
is not maintained.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>indices</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">record_delete_multiple</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.find">
<code class="descname">find</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.find" title="Permalink to this definition">¶</a></dt>
<dd><p>Search the integer part of a table for a given element or array.</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">find</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">find</code><span class="sig-paren">(</span><em>n</em><span class="optional">[</span>, <em>mask</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>n0</em><em>)</em>) – </li>
<li><strong>mask</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n1</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_i</strong> –  int</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_find_row</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">find</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>n</strong> (<em>input int</em>) – </td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><strong>ret_i</strong> –  int</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_find_element</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="classmethod">
<dt id="quippy.table.Table.from_atom_indices">
<em class="property">classmethod </em><code class="descname">from_atom_indices</code><span class="sig-paren">(</span><em>atoms</em>, <em>mask=None</em>, <em>list=None</em>, <em>force_fortran_indexing=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/table.html#Table.from_atom_indices"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.table.Table.from_atom_indices" title="Permalink to this definition">¶</a></dt>
<dd><p>Construct a new Table containing atomic indices from a list or mask</p>
<p>The new table will include 4 integer columns, for indices plus
shifts, and is suitable for passing to bfs_step,
construct_hysteretic_region, etc.</p>
<p>If force_fortran_indexing is True (the default), all atom indices
are converted to Fortran 1-based indexing.</p>
</dd></dl>

<dl class="classmethod">
<dt id="quippy.table.Table.from_atom_list">
<em class="property">classmethod </em><code class="descname">from_atom_list</code><span class="sig-paren">(</span><em>atoms</em>, <em>list</em>, <em>force_fortran_indexing=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/table.html#Table.from_atom_list"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.table.Table.from_atom_list" title="Permalink to this definition">¶</a></dt>
<dd><p>Construct a new Table from a list of atom indices</p>
<p>See Table.from_atom_indices for more details.</p>
</dd></dl>

<dl class="classmethod">
<dt id="quippy.table.Table.from_atom_mask">
<em class="property">classmethod </em><code class="descname">from_atom_mask</code><span class="sig-paren">(</span><em>atoms</em>, <em>mask</em>, <em>force_fortran_indexing=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/table.html#Table.from_atom_mask"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.table.Table.from_atom_mask" title="Permalink to this definition">¶</a></dt>
<dd><p>Construct a new Table from an atom mask</p>
<p>See Table.from_atom_indices for more details.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.insert">
<code class="descname">insert</code><span class="sig-paren">(</span><em>pos</em><span class="optional">[</span>, <em>intpart</em>, <em>realpart</em>, <em>strpart</em>, <em>logicalpart</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.insert" title="Permalink to this definition">¶</a></dt>
<dd><p>insert a row at a given position</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>pos</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
<dt><strong>intpart</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0), optional</span></dt>
<dd></dd>
<dt><strong>realpart</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘d’) with bounds (qp_n1), optional</span></dt>
<dd></dd>
<dt><strong>strpart</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-2 array(‘S’) with bounds (qp_n2,(10)), optional</span></dt>
<dd></dd>
<dt><strong>logicalpart</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n3), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">insert</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.int_part">
<code class="descname">int_part</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.int_part" title="Permalink to this definition">¶</a></dt>
<dd><p>Utility function to return one or more columns from the integer part of a table.
Since this is a function the array may be returned on the stack, so be careful
when working with large tables — the same goes for the ‘real_part’
interface below.</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">int_part</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">int_part</code><span class="sig-paren">(</span><em>column</em>, <em>n0</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>column</strong> (<em>input int</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_int_column,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_int_column</strong> –  rank-1 array(‘i’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_int_column</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">int_part</code><span class="sig-paren">(</span><em>n0</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_int_part,0)</li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_int_part,1)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_int_part</strong> –  rank-2 array(‘i’) with bounds (qp_n0,qp_n1)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_int_part</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">int_part</code><span class="sig-paren">(</span><em>columns</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>columns</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_int_columns,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_int_columns</strong> –  rank-2 array(‘i’) with bounds (size(qp_columns),qp_n1)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_int_columns</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.int_subtable">
<code class="descname">int_subtable</code><span class="sig-paren">(</span><em>rows</em>, <em>cols</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.int_subtable" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>rows</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0)</span></dt>
<dd></dd>
<dt><strong>cols</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n1)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_int_subtable</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">int_subtable</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.logical_part">
<code class="descname">logical_part</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.logical_part" title="Permalink to this definition">¶</a></dt>
<dd><p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">logical_part</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">logical_part</code><span class="sig-paren">(</span><em>n0</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_logical_part,0)</li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_logical_part,1)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_logical_part</strong> –  rank-2 array(‘i’) with bounds (qp_n0,qp_n1)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_logical_part</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">logical_part</code><span class="sig-paren">(</span><em>columns</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>columns</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_logical_columns,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_logical_columns</strong> –  rank-2 array(‘i’) with bounds (size(qp_columns),qp_n1)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_logical_columns</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">logical_part</code><span class="sig-paren">(</span><em>column</em>, <em>n0</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>column</strong> (<em>input int</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_logical_column,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_logical_column</strong> –  rank-1 array(‘i’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_logical_column</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.print_">
<code class="descname">print_</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.print_" title="Permalink to this definition">¶</a></dt>
<dd><p>Print this table to the mainlog or to an inoutput object.</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">print_</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt id="quippy.table.Table.print">
<code class="descname">print</code><span class="sig-paren">(</span><em>file</em><span class="optional">[</span>, <em>verbosity</em>, <em>real_format</em>, <em>int_format</em>, <em>str_format</em>, <em>logical_format</em>, <em>mask</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.print" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
<li><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </li>
<li><strong>file</strong> (<a class="reference internal" href="system.html#quippy.system.InOutput" title="quippy.system.InOutput"><code class="xref py py-class docutils literal notranslate"><span class="pre">InOutput</span></code></a> object) – </li>
<li><strong>real_format</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>int_format</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>str_format</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>logical_format</strong> (<em>input string</em><em>(</em><em>len=-1</em><em>)</em><em>, </em><em>optional</em>) – </li>
<li><strong>mask</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em><em>, </em><em>optional</em>) – </li>
</ul>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_print</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">print</code><span class="sig-paren">(</span><span class="optional">[</span><em>verbosity</em><span class="optional">]</span><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>verbosity</strong> (<em>input int</em><em>, </em><em>optional</em>) – </td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_print_mainlog</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.real_part">
<code class="descname">real_part</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.real_part" title="Permalink to this definition">¶</a></dt>
<dd><p>Utility function to return one or more columns from the real part of a table.</p>
<p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">real_part</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">real_part</code><span class="sig-paren">(</span><em>columns</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>columns</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_real_columns,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_real_columns</strong> –  rank-2 array(‘d’) with bounds (size(qp_columns),qp_n1)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_real_columns</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">real_part</code><span class="sig-paren">(</span><em>n0</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_real_part,0)</li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_real_part,1)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_real_part</strong> –  rank-2 array(‘d’) with bounds (qp_n0,qp_n1)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_real_part</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">real_part</code><span class="sig-paren">(</span><em>column</em>, <em>n0</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>column</strong> (<em>input int</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_real_column,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_real_column</strong> –  rank-1 array(‘d’) with bounds (qp_n0)</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_real_column</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.record_delete_multiple">
<code class="descname">record_delete_multiple</code><span class="sig-paren">(</span><em>indices</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.record_delete_multiple" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>indices</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_record_delete_multiple</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.remove_columns">
<code class="descname">remove_columns</code><span class="sig-paren">(</span><span class="optional">[</span><em>int_col_min</em>, <em>int_col_max</em>, <em>real_col_min</em>, <em>real_col_max</em>, <em>str_col_min</em>, <em>str_col_max</em>, <em>logical_col_min</em>, <em>logical_col_max</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.remove_columns" title="Permalink to this definition">¶</a></dt>
<dd><p>remove a range of columns from a table’s int or real parts</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>int_col_min</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>int_col_max</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>real_col_min</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>real_col_max</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>str_col_min</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>str_col_max</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>logical_col_min</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
<dt><strong>logical_col_max</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">remove_columns</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.search">
<code class="descname">search</code><span class="sig-paren">(</span><em>intpart</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.search" title="Permalink to this definition">¶</a></dt>
<dd><p>Do a binary search (faster than find) on a pre-sorted table</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>intpart</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0)</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_index</strong> <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">search</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.select">
<code class="descname">select</code><span class="sig-paren">(</span><em>to</em>, <em>from</em><span class="optional">[</span>, <em>row_mask</em>, <em>row_list</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.select" title="Permalink to this definition">¶</a></dt>
<dd><p>Select certains rows from a table based on a mask</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>to</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><code class="xref py py-class docutils literal notranslate"><span class="pre">table</span></code> object</span></dt>
<dd></dd>
<dt><strong>from</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><code class="xref py py-class docutils literal notranslate"><span class="pre">table</span></code> object</span></dt>
<dd></dd>
<dt><strong>row_mask</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0), optional</span></dt>
<dd></dd>
<dt><strong>row_list</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n1), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">select</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.set_increment">
<code class="descname">set_increment</code><span class="sig-paren">(</span><em>increment</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.set_increment" title="Permalink to this definition">¶</a></dt>
<dd><p>Change the increment for this table.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>increment</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">set_increment</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.sort">
<code class="descname">sort</code><span class="sig-paren">(</span><span class="optional">[</span><em>idx</em>, <em>int_cols</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.sort" title="Permalink to this definition">¶</a></dt>
<dd><p>Sort a table according to its int part</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>idx</strong> <span class="classifier-delimiter">:</span> <span class="classifier">in/output rank-1 array(‘i’) with bounds (qp_n0), optional</span></dt>
<dd></dd>
<dt><strong>int_cols</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n1), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">sort</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.str_part">
<code class="descname">str_part</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.str_part" title="Permalink to this definition">¶</a></dt>
<dd><p>Wrapper around Fortran interface <code class="docutils literal notranslate"><span class="pre">str_part</span></code> containing multiple routines:</p>
<blockquote>
<div><dl class="function">
<dt>
<code class="descname">str_part</code><span class="sig-paren">(</span><em>column</em>, <em>n0</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>column</strong> (<em>input int</em>) – </li>
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_str_column,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_str_column</strong> –  rank-2 array(‘S’) with bounds (qp_n0,(10))</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_str_column</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">str_part</code><span class="sig-paren">(</span><em>columns</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>columns</strong> (<em>input rank-1 array</em><em>(</em><em>'i'</em><em>) </em><em>with bounds</em><em> (</em><em>qp_n0</em><em>)</em>) – </li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_str_columns,0)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_str_columns</strong> –  rank-3 array(‘S’) with bounds (size(qp_columns),qp_n1,(10))</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_str_columns</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="function">
<dt>
<code class="descname">str_part</code><span class="sig-paren">(</span><em>n0</em>, <em>n1</em><span class="sig-paren">)</span></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>n0</strong> (<em>input int</em>) – shape(qp_ret_table_str_part,0)</li>
<li><strong>n1</strong> (<em>input int</em>) – shape(qp_ret_table_str_part,1)</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><strong>ret_table_str_part</strong> –  rank-3 array(‘S’) with bounds (qp_n0,qp_n1,(10))</p>
</td>
</tr>
</tbody>
</table>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">table_str_part</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

</div></blockquote>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.subtable">
<code class="descname">subtable</code><span class="sig-paren">(</span><em>rows</em><span class="optional">[</span>, <em>intcols</em>, <em>realcols</em>, <em>strcols</em>, <em>logicalcols</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.subtable" title="Permalink to this definition">¶</a></dt>
<dd><table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first docutils">
<dt><strong>rows</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n0)</span></dt>
<dd></dd>
<dt><strong>intcols</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n1), optional</span></dt>
<dd></dd>
<dt><strong>realcols</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n2), optional</span></dt>
<dd></dd>
<dt><strong>strcols</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n3), optional</span></dt>
<dd></dd>
<dt><strong>logicalcols</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input rank-1 array(‘i’) with bounds (qp_n4), optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>ret_subtable</strong> <span class="classifier-delimiter">:</span> <span class="classifier"><a class="reference internal" href="#quippy.table.Table" title="quippy.table.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">subtable</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.to_atom_list">
<code class="descname">to_atom_list</code><span class="sig-paren">(</span><em>atoms=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/table.html#Table.to_atom_list"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.table.Table.to_atom_list" title="Permalink to this definition">¶</a></dt>
<dd><p>Return list of atom indices that this Table represents.</p>
<p>Indices returns are 0-based or 1-based depending on value of
<code class="xref py py-func docutils literal notranslate"><span class="pre">get_fortran_indexing()</span></code>.</p>
<p>If <cite>atoms</cite> is not present, the Atoms object passed to
Table.from_atom_indices is used, or an exception is raised if this
Table was not created in that way.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.to_atom_mask">
<code class="descname">to_atom_mask</code><span class="sig-paren">(</span><em>atoms=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/quippy/table.html#Table.to_atom_mask"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#quippy.table.Table.to_atom_mask" title="Permalink to this definition">¶</a></dt>
<dd><p>Return mask for atom indices that this Table represents</p>
<p>Result is either an array of an FortranArray, depending on
value of <code class="xref py py-func docutils literal notranslate"><span class="pre">get_fortran_indexing()</span></code>.</p>
<p>If <cite>atoms</cite> is not present, the Atoms object passed to
Table.from_atom_indices is used, or an exception is raised if this
Table was not created in that way.</p>
</dd></dl>

<dl class="method">
<dt id="quippy.table.Table.wipe">
<code class="descname">wipe</code><span class="sig-paren">(</span><span class="optional">[</span><em>zero</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#quippy.table.Table.wipe" title="Permalink to this definition">¶</a></dt>
<dd><p>Clear this table, but keep the allocation.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><dl class="first last docutils">
<dt><strong>zero</strong> <span class="classifier-delimiter">:</span> <span class="classifier">input int, optional</span></dt>
<dd></dd>
</dl>
</td>
</tr>
</tbody>
</table>
<p class="rubric">References</p>
<p>Routine is wrapper around Fortran routine <code class="docutils literal notranslate"><span class="pre">wipe</span></code> defined in file <a class="reference external" href="https://github.com/libAtoms/QUIP/blob/public/src/libAtoms/Table.f95">src/libAtoms/Table.f95</a>.</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.increment">
<code class="descname">increment</code><a class="headerlink" href="#quippy.table.Table.increment" title="Permalink to this definition">¶</a></dt>
<dd><p>How many rows to grow the table by on reallocation (default 1000)</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.int">
<code class="descname">int</code><a class="headerlink" href="#quippy.table.Table.int" title="Permalink to this definition">¶</a></dt>
<dd><p>(intsize,N) array of integer data</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.intsize">
<code class="descname">intsize</code><a class="headerlink" href="#quippy.table.Table.intsize" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of integer columns</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.logical">
<code class="descname">logical</code><a class="headerlink" href="#quippy.table.Table.logical" title="Permalink to this definition">¶</a></dt>
<dd><p>(logicalsize,N) array of logical data</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.logicalsize">
<code class="descname">logicalsize</code><a class="headerlink" href="#quippy.table.Table.logicalsize" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of logical columns</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.max_length">
<code class="descname">max_length</code><a class="headerlink" href="#quippy.table.Table.max_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial maximum length of the table before the first reallocation (default 100)</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.n">
<code class="descname">n</code><a class="headerlink" href="#quippy.table.Table.n" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of rows</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.real">
<code class="descname">real</code><a class="headerlink" href="#quippy.table.Table.real" title="Permalink to this definition">¶</a></dt>
<dd><p>(realsize,N) array of real data</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.realsize">
<code class="descname">realsize</code><a class="headerlink" href="#quippy.table.Table.realsize" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of real columns</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.str">
<code class="descname">str</code><a class="headerlink" href="#quippy.table.Table.str" title="Permalink to this definition">¶</a></dt>
<dd><p>(strsize,N) array of string data</p>
</dd></dl>

<dl class="attribute">
<dt id="quippy.table.Table.strsize">
<code class="descname">strsize</code><a class="headerlink" href="#quippy.table.Table.strsize" title="Permalink to this definition">¶</a></dt>
<dd><p>Number of string columns</p>
</dd></dl>

</dd></dl>

</div>


           </div>
           
          </div>
          <footer>
  

  <hr/>

  <div role="contentinfo">
    <p>
        &copy; Copyright 2008-2016, James Kermode

    </p>
  </div>
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  


  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.Navigation.enable(true);
      });
  </script>

  
  
    
   

</body>
</html>